.TH std::reference_wrapper::operator() 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::reference_wrapper::operator() \- std::reference_wrapper::operator()

.SH Synopsis
   template< class... ArgTypes >
                                                                       \fI(since C++11)\fP
   typename std::result_of<T&(ArgTypes&&...)>::type                    \fI(until C++17)\fP

       operator() ( ArgTypes&&... args ) const;
   template< class... ArgTypes >
                                                                       \fI(since C++17)\fP
   std::invoke_result_t<T&, ArgTypes...>                               (constexpr since
                                                                       C++20)
       operator() ( ArgTypes&&... args ) const noexcept(/* see below
   */);

   Calls the Callable object, reference to which is stored, as if by INVOKE(get(),
   std::forward<ArgTypes>(args)...). This function is available only if the stored
   reference points to a Callable object.

   T must be a complete type.

.SH Parameters

   args - arguments to pass to the called function

.SH Return value

   The return value of the called function.

.SH Exceptions

   May throw implementation-defined exceptions.           \fI(since C++11)\fP
                                                          \fI(until C++17)\fP
   noexcept specification:                                \fI(since C++17)\fP
   noexcept(std::is_nothrow_invocable_v<T&, ArgTypes...>)

.SH Example


// Run this code

 #include <functional>
 #include <iostream>

 void f1()
 {
     std::cout << "reference to function called\\n";
 }

 void f2(int n)
 {
     std::cout << "bind expression called with " << n << " as the argument\\n";
 }

 int main()
 {
     std::reference_wrapper<void()> ref1 = std::ref(f1);
     ref1();

     auto b = std::bind(f2, std::placeholders::_1);
     auto ref2 = std::ref(b);
     ref2(7);

     auto c = []{ std::cout << "lambda function called\\n"; };
     auto ref3 = std::ref(c);
     ref3();
 }

.SH Output:

 reference to function called
 bind expression called with 7 as the argument
 lambda function called

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to   Behavior as published     Correct behavior
   LWG 3764 C++17      operator() is not noexcept propagate noexcept

.SH See also

   get         accesses the stored reference
   operator T& \fI(public member function)\fP

.SH Category:
     * conditionally noexcept
